Revista do CD-ROM 101/CD-ROM 101.iso/compl/maya5ple/Install_MayaPLE5_English.exe/Maya/Data1.cab/doSetFluidAttrFromCurve.mel

Text File | 2003-07-17 | 10.8 KB | 382 lines

// Copyright (C) 1997-2002 Alias|Wavefront,
// a division of Silicon Graphics Limited.
//
// The information in this file is provided for the exclusive use of the
// licensees of Alias|Wavefront.  Such users have the right to use, modify,
// and incorporate this code into other products for purposes authorized
// by the Alias|Wavefront license agreement, without fee.
//
// ALIAS|WAVEFRONT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
// INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
// EVENT SHALL ALIAS|WAVEFRONT BE LIABLE FOR ANY SPECIAL, INDIRECT OR
// CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
// DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.
//
//
//  Alias|Wavefront Script File
//  MODIFY THIS AT YOUR OWN RISK
//
//  Creation Date:  Oct 21, 2002
//
//  Description:
//      Sets fluid properties at locations
//      determined by a NURBS curve intersecting
//      the voxel grid.
//
//
//  Input Arguments:
//      None.
//
//  Return Vaalue:
//      None.
//
proc int[] voxelFromPosition( string $fluid, float $pos[], float $radius )
{
    int $voxels[] = `fluidVoxelInfo -radius $radius -objectSpace false -cb
                    -voxel $pos[0] $pos[1] $pos[2] $fluid`;
    return $voxels;
}

proc setTangentVelocity( string $fluid, string $parent,
                         float $tan[], int $vox[],
                         float $value, int $absolute )
//
// Description:
//    Set the velocity values in voxels that intersect the
//    curve (at the current curveInfo position) based on the
//    tangent direction of the curve at the point.
//
{
    // Convert to fluid space
    //
    float $inverse[] = `getAttr($parent + ".worldInverseMatrix[0]")`;
    $tan = pointMatrixMult( $tan, $inverse );

    float $vel[] = { $value*$tan[0], $value*$tan[1], $value*$tan[2] };

    if( !$absolute ) {
        float $oldVel[] = `getFluidAttr -at "velocity"
            -xi $vox[0] -yi $vox[1] -zi $vox[2] $fluid`;

        $vel[0] = $vel[0] + $oldVel[0];
        $vel[1] = $vel[1] + $oldVel[1];
        $vel[2] = $vel[2] + $oldVel[2];
    }

    eval( "setFluidAttr -lf -at velocity -vv " +
          $vel[0] + " " + $vel[1] + " " + $vel[2] + " " +
          " -xi " + $vox[0] + " -yi " + $vox[1] + " -zi " + $vox[2]
          + " " + $fluid );

    setAttr ($parent + ".velocityDraw") 1;
}

proc setScalar( string $fluid, int $vox[], string $attr,
                float $value, int $absolute )
//
// Description:
//    Sets a scalar-valued attribute at the voxel intersecting
//    the current curve position.
//
{
    int $i;
    for( $i = 0; $i < size( $vox ); $i += 3 ) {
        int $x = $vox[$i+0];
        int $y = $vox[$i+1];
        int $z = $vox[$i+2];

        float $newValue = $value;
        if( !$absolute ) {
            float $oldVal[] = `getFluidAttr -at $attr
                -xi $x -yi $y -zi $z $fluid`;

            $newValue += $oldVal[0];
        }

        eval( "setFluidAttr -at " + $attr + " -fv " + $newValue +
              " -xi " + $x + " -yi " + $y + " -zi " + $z +
              " " + $fluid );
    }
}

proc setColor( string $fluid, int $vox[],
               float $color[], int $absolute )
//
// Description:
//    Sets voxel color at the intersection with the current
//    curve position.
//
{
    if( !$absolute ) {
        float $oldVal[] = `getFluidAttr -at "color"
            -xi $vox[0] -yi $vox[1] -zi $vox[2] $fluid`;

        $color[0] += $oldVal[0];
        $color[1] += $oldVal[1];
        $color[2] += $oldVal[2];
    }

    eval( "setFluidAttr -at color -vv " +
          $color[0] + " " + $color[1] + " " + $color[2] +
          " -xi " + $vox[0] + " -yi " + $vox[1] + " -zi " + $vox[2] +
          " " + $fluid );
}

proc addUniqueVoxelsToTargets( int $newVox[], int $voxels[],
                               float $newTan[], float $tangents[],
                               string $fluid,
                               float $position[], float $distances[] )
//
// Description:
//    Voxels could be added multiple times because of
//    small parametric step values along the curve, or
//    because of high radii values.  This could cause
//    problems in add mode (processing the added value
//    once for each repeated occurrence).
//
//    So, before adding any voxel to the list of targets to
//    process, search the existing target list first to see if
//    it's already there.  (This is slow due to lack of
//  good array utility procs in MEL, but probably
//    acceptable for most usable fluid resolutions.)
//
//    We also pass in the current position and the distances
//    to that position as each voxel is processed.  This way,
//    we can make sure the values stuffed into a voxel come
//    from the closest current position, and not some further
//    away voxel processed because of a high radius, for
//    instance.  This is necessary only for velocity tangent
//    info, since the values put into the voxels depend on
//    tangent information at the closest point.
//
{
    int $i, $j;
    for( $i = 0; $i < size( $newVox ); $i+=3 ) {
        int $found = false;

        // Get the position of the voxel center.
        //
        float $voxPos[] = `fluidVoxelInfo -vc -xi $newVox[$i] -objectSpace 0
            -yi $newVox[$i+1] -zi $newVox[$i+2] $fluid`;

        // How far away is it from the current position
        // for which we're accumulating voxels?
        //
        float $dist = sqrt( pow( $voxPos[0] - $position[0], 2 ) +
                            pow( $voxPos[1] - $position[1], 2 ) +
                            pow( $voxPos[2] - $position[2], 2 ) );

        for( $j = 0; $j < size( $voxels ); $j+=3 ) {
            if( $newVox[$i+0] == $voxels[$j+0] &&
                $newVox[$i+1] == $voxels[$j+1] &&
                $newVox[$i+2] == $voxels[$j+2] )
            {
                $found = true;

                // If the voxel was already in the list, update
                // its distance values, if this voxel is closer
                // to the current position than the last current
                // position that added this particular voxel.
                //
                if( $dist < $distances[$j] ) {
                    $distances[$j+0] = $dist;
                    $distances[$j+1] = $dist;
                    $distances[$j+2] = $dist;

                    $tangents[$j+0] = $newTan[0];
                    $tangents[$j+1] = $newTan[1];
                    $tangents[$j+2] = $newTan[2];
                }

                break;
            }
        }

        if( !$found ) {
            $voxels[ size($voxels) ] = $newVox[$i+0];
            $voxels[ size($voxels) ] = $newVox[$i+1];
            $voxels[ size($voxels) ] = $newVox[$i+2];

            $tangents[ size($tangents) ] = $newTan[0];
            $tangents[ size($tangents) ] = $newTan[1];
            $tangents[ size($tangents) ] = $newTan[2];

            $distances[ size($distances) ] = $dist;
            $distances[ size($distances) ] = $dist;
            $distances[ size($distances) ] = $dist;
        }
    }

    if( size( $voxels ) != size( $tangents ) ) {
        error( "addUniqueVoxelsToTargets: array size mismatch." );
    }
}

global proc doSetFluidAttrFromCurve( int $version,
                                     string $args[] )
{
    if(( $version < 1 ) || ( size( $args ) < 17 )) {
        error( "Incorrect version/argument list" );
        return;
    }

    int   $doAttr[] = { int( $args[0] ), $args[1], $args[2],
                        $args[3], $args[4] };
    float $values[] = { float($args[5]), $args[6], $args[7], $args[8],
                        $args[9], $args[10], $args[11]};
    int   $absolute = ($args[12] == 2);        // 1 is relative (add)

    float $numSteps = (float) $args[13];
    if( $numSteps < 1.0 ) {
        $numSteps = 1.0;
    }
    if( $numSteps > 1000.0 ) {
        $numSteps = 1000.0;
    }

    float $radius = (float) $args[14];

    float $percentageStep = 1.0 / $numSteps; // have num steps,  need .001 to 1
    int   $normalizeTangents = $args[15];
    int   $setInitialState = $args[16];

    string $fluids[] = `ls -dag -sl -type fluidShape`;
    string $curves[] = `ls -dag -sl -type nurbsCurve`;

    if(( size( $fluids ) != 1 ) || ( size( $curves ) < 1 ))
    {
        error( "Please select one fluid shape and at least one NURBS curve." );
        return;
    }

    waitCursor -state on;

    string $fluid = $fluids[0];
    string $selection[] = `ls -sl`;

    string $curve;
    for( $curve in $curves ) {
        string $curveInfo = `createNode pointOnCurveInfo`;
        string $inAttr = $curve + ".ws[0]";
        string $outAttr = $curveInfo + ".ic";
        connectAttr $inAttr $outAttr;

        setAttr ( $curveInfo + ".turnOnPercentage" ) true;

        // Figure out the inverse matrix of the fluid for later.
        //
        select $fluid;
        string $parents[] = `pickWalk -d up`;
        string $parent = $parents[0];

        string $attributes[] = { "density",
                                 "velocity",
                                 "temperature",
                                 "fuel",
                                 "color" };

        int $whichAttr = -1;
        int $whichValue = -1;
        for( $attr in $attributes ) {
            $whichAttr++;
            $whichValue++;
            if( !$doAttr[$whichAttr] ) {
                continue;
            }

            string $createGridCmd[];
            if( !fluidsVerifyGrid( $fluid, $attr, $createGridCmd ) ) {
                warning( "Contents Method " + $attr + " for " + $fluid +
                         " is not set to either Dynamic or Static Grid; " +
                         " skipping." );
                continue;
            }

            float $value = 1.0;
            if( $whichValue < size( $values ) ) {
                $value = $values[$whichValue];
            }

            int $voxels[];
            float $tangents[];
            float $distances[];
            float $i;

            // Accumulate all the voxels we'll have to set
            // values for...  We can prune out the duplicates,
            // and save time processing each voxel only once.
            //
            for( $i = 0.0; $i <= 1.0; $i += $percentageStep ) {
                setAttr ( $curveInfo + ".parameter" ) $i;

                // Get the tangent in world space
                //
                float $newTan[];
                if( $normalizeTangents == 1 ) {    // constant
                    $newTan = `getAttr($curveInfo + ".normalizedTangent")`;
                } else {                            // tangential
                    $newTan = `getAttr($curveInfo + ".tangent")`;
                }

                // Get the point position along the curve
                //
                float $curr[] = `getAttr ( $curveInfo + ".position" )`;
                int $newVox[] = voxelFromPosition( $fluid, $curr, $radius );

                addUniqueVoxelsToTargets( $newVox, $voxels,
                                          $newTan, $tangents,
                                          $fluid, $curr, $distances );
            }

            int $j;
            for ($j = 0; $j < size( $voxels ); $j+=3 ) {
                int $vox[] = {     $voxels[$j+0],
                                $voxels[$j+1],
                                $voxels[$j+2] } ;


                float $tan[] = { $tangents[$j+0],
                                 $tangents[$j+1],
                                 $tangents[$j+2] };

                if( $attr == "velocity" ) {
                    setTangentVelocity( $fluid, $parent, $tan,
                                        $vox, $value, $absolute );
                } else if( $attr == "color" ) {
                    float $color[] = { $value,
                                       $values[$whichValue+1],
                                       $values[$whichValue+2] };
                    setColor( $fluid, $vox, $color, $absolute );
                } else {
                    setScalar( $fluid, $vox, $attr, $value, $absolute );
                }
            }

            // If color, bump the whichAttr counter by the two
            // extra values
            //
            if( $attr == "color" ) {
                $whichValue+=2;
            }
        }

        // Cleanup and select fluid.
        //
        delete $curveInfo;
    }

    select $selection;

    // Optionally set the initial state, if the user
    // requests to, so he doesn't lose the values coming
    // from the curve if he rewinds.
    //
    if( $setInitialState ) {
        SetInitialState;
    }

    waitCursor -state off;
}